In [2]:
import math
def funcion(x):
return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
def biseccion(intA, intB, errorA, noMaxIter):
if(funcion(intA)*funcion(intB)<0):
noIter = 0
errorTmp = 1
intTmp = 0
oldInt = intA
while(noIter<noMaxIter and errorTmp>errorA and funcion(intTmp)!=0):
intTmp = (intB+intA)/2
if(funcion(intA)*funcion(intTmp)<0):
intB = intTmp
else:
intA = intTmp
noIter+=1
errorTmp=abs((intTmp-oldInt)/intTmp)*100
oldInt = intTmp
#print('Error: ',errorTmp)
print('La raíz es: ',intTmp)
print('F(raiz) es:' ,funcion(intTmp))
print('Error: ',errorTmp)
print('No. de iteraciones realizadas: ',noIter)
else:
print('En el intervalo dado la función no presenta cambio de signo')
print('No hay raices que encontrar')
biseccion(-1,0,math.pow(10,-6),1000)
In [1]:
import math
def funcion(x):
return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
def reglaFalsa(intA, intB, errorA, noMaxIter):
if(funcion(intA)*funcion(intB)<0):
noIter = 0
errorTmp = 1
intTmp = 0
oldInt = intA
while(noIter<noMaxIter and errorTmp>errorA and funcion(intTmp)!=0):
intTmp = intB-((funcion(intB)*(intA+intB))/(funcion(intA)-funcion(intB)))
if(funcion(intA)*funcion(intTmp)<0):
intB = intTmp
else:
intA = intTmp
noIter+=1
errorTmp=abs((intTmp-oldInt)/intTmp)*100
oldInt = intTmp
#print('Error: ',errorTmp)
print('La raíz es: ',intTmp)
print('F(raiz) es:' ,funcion(intTmp))
print('Error: ',errorTmp)
print('No. de iteraciones realizadas: ',noIter)
else:
print('En el intervalo dado la función no presenta cambio de signo')
print('No hay raices que encontrar')
reglaFalsa(-1,0,math.pow(10,-6),1000)
In [18]:
import math
def funcion(x):
return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
def funcionDeriv(x):
return (6*math.pow(math.e,6*x))-(8.316*math.pow(math.e,4*x))+(2.88*math.pow(math.e,2*x))
def newtonRaphson(val, errorA, noMaxIter):
noIter = 0
errorTmp = 1
intTmp = 0
while(noIter<noMaxIter and errorTmp>errorA and funcion(intTmp)!=0):
valTmp = val-((funcion(val))/(funcionDeriv(val)))
errorTmp=abs((valTmp-val)/valTmp)*100
val = valTmp
noIter+=1
print('La raíz es: ',valTmp)
print('F(raiz) es:' ,funcion(valTmp))
print('Error: ',errorTmp)
print('No. de iteraciones realizadas: ',noIter)
print('------------------------------------')
print('Valor inicial : -1')
newtonRaphson(-1, math.pow(10,-6),1000)
print('------------------------------------')
print('Valor inicial : -3')
newtonRaphson(-3, math.pow(10,-6),1000)
print('------------------------------------')
In [24]:
import math
def funcion(x):
return (math.pow(math.e,6*x))+(1.44*math.pow(math.e,2*x))-(2.079*math.pow(math.e,4*x))-(0.333)
def secante(primerVal, segundoVal, errorA, noMaxIter):
noIter = 0
errorTmp = 1
intTmp = 0
while(noIter<noMaxIter and errorTmp>errorA and funcion(segundoVal)!=0):
valTmp = segundoVal-((funcion(segundoVal)*(primerVal-segundoVal))/(funcion(primerVal)-funcion(segundoVal)))
primerVal = segundoVal
segundoVal = valTmp
errorTmp=abs((segundoVal-primerVal)/segundoVal)*100
#print('Noiter: ',noIter, ' primVal:', primerVal,' segunVal:',segundoVal,' error:',errorTmp)
noIter+=1
print('La raíz es: ',valTmp)
print('F(raiz) es:' ,funcion(valTmp))
print('Error: ',errorTmp)
print('No. de iteraciones realizadas: ',noIter)
print('------------------------------------')
print('Valor inicial : -1 y 0')
secante(-1,0,math.pow(10,-6),1000)
print('------------------------------------')
print('Valor inicial : -3 y -1')
secante(-3,-1,math.pow(10,-6),3000)
print('------------------------------------')
En los resultados del punto anterior se puede ver que el método que más rápido converge de los 4 es el de secante con valores iniciales entre -1 y 0.
Es importante aclarar que los métodos convergen mas rápidamente a la aproximación deseada cuando se toman valores iniciales cercanos a la raíz, esto se demuestra al ver los resultados del método de Newton - Raphson y secante con valor de -3.
Al empezar estos métodos con valores tan distantes de la raíz y ser esta una función polinómica con términos exponenciales se puede ver como necesitan de muchas iteraciones para alcanzar una aproximación aceptable (10^-6)
También se puede observar como el método de regla falsa no es óptimo debido al comportamiento de la función en el área cercana a la raíz, su pendiente no cambia lo suficientemente rápido como para que el método pueda aprovechar su naturaleza
Finalmente vale la pena destacar lo óptimo que son los métodos abiertos sobre los métodos cerrados cuando se toman valores iniciales relativamente cercanos a la raíz. Ambos realizaron menos iteraciones que la mitad de el método de bisecciñon (el mejor de los dos métodos cerrados probados)